Apply various formatting fixes - #80

I find this not so easy to read, because WHEN and THEN blocks are indented the same amount. IMHO it's sort of like formatting if-else in some other language like so:

if x > 10
return 15
else if x < 10
return 20

It also doesn't match with how the procedural version of CASE expression gets formatted:

CASE
  WHEN column_name = 1 THEN
    SELECT \good'
  WHEN columne_name = 2 THEN
    SELECT 'bad'
  ELSE
    SELECT 'other'
END CASE

See case.test.ts

I would go with similar indentation for the long WHEN..THEN blocks in general:

CASE
  WHEN column_name = 1 THEN
    result_name
  WHEN columne_name = 2 THEN
    other_result
  ELSE
    foo
END CASE

Makes sense. So for multi-line WHEN/THEN clauses, will it be okay to format as follows?

CASE
  WHEN 
    column_name = 1 
    AND (column_name = 2 OR column_name = 3)
    AND column_name = 4 THEN
      result_name
      AND (result_name OR result_name)
  WHEN columne_name = 5 THEN
    other_result
  ELSE
    foo
END

I think it would be better to treat the WHEN .. THEN pair as ( .. ) pair in C-style if statement, which in Prettier would get formatted like:

if (
  column_name === 1 
  && (column_name === 2 OR column_name === 3)
  && column_name === 4
) {
  return result_name
} else if (columne_name === 5) {
  return other_result;
}

So in SQL this would be:

CASE
  WHEN 
    column_name = 1 
    AND (column_name = 2 OR column_name = 3)
    AND column_name = 4
  THEN
    result_name
  WHEN columne_name = 5 THEN
    other_result
  ELSE
    foo
END

This has the nice property, that the body of THEN is always indented the same amount. When the code between WHEN..THEN needs to wrap to multiple lines, the code coming after THEN won't need to be reformatted in any way.

I think these tests have become obsolete now that we always break. Best to remove

I think I gave you the wrong idea when I said we should format the case expression the same as the case statement in procedural SQL. What I meant was, that we should format them similarly when they are so long that they don't fit on a single line. That is, I'd still expect to format the above as:

CASE x
  WHEN 1 THEN 'A'
  ELSE 'B'
END

Only when the expression doesn't fit on a single line should be break the WHEN..THEN or ELSE block to multiple lines like so:

CASE x
  WHEN 1 THEN
    'Something long in here'
  ELSE
    'Another long thing in here'
END

or when the condition part is long:

CASE x
  WHEN some_long_expression_in_here THEN
    'A'
  ELSE
    'B'
END

or extra long:

CASE x
  WHEN
    some_extra_long_expression_in_here
  THEN
    'A'
  ELSE
    'B'
END

What I meant was, that we should format them similarly when they are so long that they don't fit on a single line.

This was what I understood at first, but I changed the implementation because of the desired ELSE formatting. With the current code setup, the ELSE clause is formatted separately/independently, so a "short" ELSE gets formatted as follows (regardless of THENs formatting):

CASE x
  WHEN some_long_expression_in_here THEN
    'A'
  ELSE 'B'
END

Alternatively, the current implementation could be changed to couple WHEN/THEN/ELSE formatting, so we can know to break the ELSE statement if the WHEN/THEN statements also break.

Or alternatively, always break the statements, which also happens to look like if..else statements (with braces). So when I got to this point I thought this what you meant all along :)

Anyway to summarise, I think the options are:

1. Format WHEN/THEN and ELSE independently and acknowledge that sometimes the ELSE will be formatted differently from the WHEN/THEN statements
2. Update the formatting code to couple WHEN/THEN/ELSE formatting. I didn't explore this too much but I felt like it would be a non-trivial overhaul -- I could be wrong
3. Always break THEN and ELSE clauses to the next line
4. Maybe something else?

Yeah, I'm leaning towards option 2. But I also don't really know how to easily achieve that. Although I'm not 100% sure we want that. The bad thing with this variant is that making one WHEN-block longer would cause a large reindent for all of them. That might or might not be what one desires. Like, if one has a long CASE expression with lots of small WHEN-THEN blocks, and then one that's a bit longer, it could be annoying to have everything split to multiple lines because of that one block. On the other hand, it can be annoying to have a mix of one-line and two-line WHEN-THEN blocks.

But option 1 is definitely the next best thing. And maybe it's even the better variant out of the two. Let's go with that and not try to fight too much with the general indentation approach of Prettier.